package com.niit.scala

import scala.collection.mutable
import scala.collection.mutable.{ArrayBuffer, ListBuffer}

object Base_06 {

  def main(args: Array[String]): Unit = {
    /*
      数组：
          1.定长数组
          2.变长数组
          3.数组的修改
          4.数组的遍历
     */

    //定长数组：长度不允许改变  var/val 变量名 = new Array[数据类型](长度)
    var arr1 = new Array[Int](10) //最大索引值 = 长度 - 1
    var arr2 = Array(10,20,30,40,50)
    println(arr2(1)) // 答案 20

    //变长数组 ：长度允许改变  var/val 变量名 = ArrayBuffer[数据类型]()
    var ab1 = ArrayBuffer[Int]()
    var ab2 = ArrayBuffer("Java","Scala","C/C++","Hadoop","HBase","Python")

    //数组的 修改 增加 删除
    //追加单个数据
    ab2 += "Kafka"
    println(ab2)
    //追加多个数据
    ab2 ++= Array("HTML","CSS","BootStrap")
    println(ab2)
    //删除单个数据
    ab2 -= "Kafka"
    println(ab2)
    //删除多个数据
    ab2 --= Array("Java", "Scala")
    println(ab2)
    //根据索引值进行数据修改
    ab2(0) = "JS"
    println(ab2)
    //数组的遍历
    //方式一
    for ( i <- 0 to ab2.length-1)  println(ab2(i))
    //方式二
    for ( i <- 0 until  ab2.length)  println(ab2(i)) //until 表示的是一个左闭右开的一个区间
    //方式三
    for (i <- ab2) println(i) //i 就是数组中每一个元素

    /*
    元组：元组一般用来存储不同类型的数据，并且长度和元素都不可以改变
     1.元组的定义
     2.访问元组中的元素
     */
    //元组的定义
    var tuple1 = ("张三",'男',23)
    //访问元组 不在通过索引值，而是通过序号进行访问
    println( tuple1._2 )
    //元组的遍历，前提先用元组生成一个迭代器对象，才可以遍历
    val tl =  tuple1.productIterator //获得元组迭代器
    for ( i <- tl) println(i)

    /*
     列表 特点：有序 可重复
     1.不可变列表
     2.可变列表
     3.列表的基本操作
     4.列表的扁平化
     5.列表的拉链与拉开
     6.列表的交并差
     */
      //不可变列表
    val list1 = List(3,4,1,4,2,3)
    val list2 = Nil //创建一个不可变的空列表
    val list3 = 2 :: 1 :: Nil //使用双冒号方式创建列表 包含了2 和 1
    println(list1,"\n",list2,"\n",list3)

    //可变列表
    val lb1 = ListBuffer[Int]()
    val lb2 = ListBuffer(1,2,3,4,5,6,7,8)

    //列表的基本操作
    //添加元素
    lb2 += 100
    lb2 ++= List(2,3,4,5)
    //删除元素
    lb2 -= 2
    lb2 --= List(2,3,4)
    //获取列表中的元素
    println(lb2(0))
    //遍历列表
    for(i <- lb2) println( i )
    //将可变列表 转为 不可变列表
    val list4 =  lb2.toList
    //列表去重
    val lb3 = lb2.distinct //去重后会返回一个新列表
    println(lb3)
    //获得列表中的首个元素
    var head =  lb2.head
    println(head)
    //获得列表中除首页元素外的元素
    val tail = lb2.tail
    println(tail)
    //take:获得从前往后数多少元素  drop:删除前几个元素
    println(lb2)
    var take= lb2.take(3)
    println(take)
    var drop = lb2.drop(3)
    println(drop)

    //列表的扁平化 嵌套列表中的所有元素，单独的放到一个新列表当中
    //将列表中的所有子列表的数据 压缩 到一个 新列表当中
    val list5 = List( List(1,2) ,List(3,4), List(5,6))
    val list6 =  list5.flatten
    // List(1,2,3,4,5,6)
    println(list5,"\n",list6)

    //列表的拉链与拉开
    //拉链：将两个列表的元素按序对应形成一个元组，并将每一个元素添加到列表当中
    //如果其中一个列表的元素较多，那么在拉链后会舍弃该元素
    val names = List("张三","李四","王五","马六","老八")
    val ages = List(23,24,25,33)
    val list7 = names.zip(ages)
    println(list7)
    //拉开：将一个包含元组的列表，拆解成两个列表的元组
    val tulpe3 =  list7.unzip
    println(tulpe3)
    //列表的交并差
    var list8 = List(1,2,3,4)
    var list9 = List(3,4,5,6)
    //并集
    var value1 =  list8.union(list9)
    println(value1)
    //交集
    var value2 = list8.intersect(list9)
    println(value2)
    //差集
    var value3 = list8.diff(list9)
    println(value3)

    /*
     集 ：无序（添加的顺序和取出的顺序不一致） 唯一
      1.不可变集
      2.可变集
      3.集合的基本操作
     */
    //不可变集
    var set1 = Set[Int]() //不可变的空集
    var set2 = Set(2,1,3,2,3,4,1)
    println(set2)

    //可变集 要想使用可变集 需要引包
    import scala.collection.mutable.Set
    var set3 = Set(2,1,3,5,6,7,8)

    //集的基本操作
    //删除元素 2
    val set4 = set3 - 2
    println(set4)
    val set5 =  set3 + 9
    println(set5)
    set3 += 10
    set3 ++= Set(11,12,13)
    set3 -= 6
    set3 --= Set(1,3,5)
    println(set3)
    for (i <- set3){
      println( i )
    }

    /*
     映射： -> 字典 -> Map -> 键值对
      不可变Map
      可变Map
      Map的基本操作
     */
    //不可变Map
    val map1: Map[String, Int] = Map(("张三", 23), ("李四", 24), ("王五", 25))
    val map2: Map[String, Int] = Map("张三" -> 23, "李四" -> 24, "王五" -> 25)
    //可变Map 需要手动引包
    import scala.collection.mutable.Map
    val map3: mutable.Map[String, Int] = Map(("张三", 23), ("李四", 24), ("王五", 25))
   //Map的基本操作
    //根据Key获取值和修改值
    println(map3.get("李四"))
    map3("张三") = 30
    println(map3("张三"))

    // map3.get("李四")  map3("张三")
    println( map3.get("老六") ) //None get的方式：如果键不存在，不会报错返回的是None
    //println(map3("老六")) // 会报错，找不到这个Key NoSuchElementException: key not found: 老六
    //获得所有键 和 获得所有值
    println("获得所有Keys:"+ map3.keys)
    println("获得所有Values:"+ map3.values)
    //遍历Map
    for ( (k,v) <- map3 ){
      println("键："+k,"值："+v)
    }

    /*
    迭代器：Scala针对每一类集合都提供了一个迭代器，用来做集合遍历访问
        迭代器通常和while配合使用
         hasNext:查询迭代器中是否含有下一个元素
         next：移动角标，返回元素
     */
    var list10 = (1 to 10).toList
    //获得迭代器
    val iterator: Iterator[Int] = list10.iterator
    while (iterator.hasNext){
      val i = iterator.next()
      println(i)
    }
}

}
